Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@include/storage/heap_table.hpp`:
- Around line 40-44: The header changed the null sentinel for TupleId to use
page_num == UINT32_MAX, so replace all hard-coded invalid RIDs written as {0, 0}
with TupleId{} (default ctor) to preserve the null semantics; specifically
update the initialization of Iterator::last_id_ (seed value) and the code path
that returns an invalid RID on insert failure to return TupleId{} instead of
{0,0}, and grep for any other occurrences of literal {0,0} that represent “no
tuple” and fix them similarly.

In `@src/storage/buffer_pool_manager.cpp`:
- Around line 108-109: The frame is being made evictable via
replacer_.unpin(frame_id) and then immediately pushed into free_list_ causing
duplication; modify the logic in the function containing
replacer_.unpin(frame_id); free_list_.push_back(frame_id) so a frame is only
returned from one source: either remove the replacer_.unpin call when you intend
to move the frame to free_list_ (so only free_list_ holds it), or instead
check/avoid pushing frames already managed by the replacer (use the same
ownership path as unpin_page_by_id()). Ensure you update the code paths that
manipulate frame_id to use replacer_.unpin exclusively or free_list_.push_back
exclusively to prevent the frame being allocatable from two places.

In `@src/storage/heap_table.cpp`:
- Around line 546-550: The code in get_meta() is making get_meta() hide
logically-deleted tuples by checking out_meta.xmax and returning false, which
breaks callers that expect raw metadata (e.g., executor::operator uses
get_meta() and applies snapshot rules). Revert this: remove the deletion-check
early return in the get_meta() path (and keep the page unpin semantics correct)
so get_meta() continues to return raw meta regardless of xmax; then move the
deleted-tuple filtering into the visibility-aware read path (either
heap_table::get() or a new helper like is_visible_under_snapshot()) and update
callers (e.g., operator.cpp usage) to call that visibility helper or let get()
enforce plain-read hiding if desired.
- Around line 546-549: The fast-path early return unpins the page via
bpm_.unpin_page_by_id(file_id_, tuple_id.page_num, false) even when the page is
stored in cached_page_, leaving cached_page_ as a dangling/stale owned pointer;
change the logic in the block that checks out_meta.xmax != 0 to avoid unpinning
a cached_page_ (either skip bpm_.unpin_page_by_id when cached_page_ is set or
first clear/reset cached_page_ before unpinning) so cached_page_ no longer holds
a stale reference — update the code around cached_page_, bpm_.unpin_page_by_id,
file_id_, and tuple_id.page_num accordingly.

In `@tests/heap_table_tests.cpp`:
- Around line 345-366: The test reads HeapTable::TupleMeta fields after calling
table_->get_meta(rid, meta) without asserting the call succeeded; update the
tests (e.g., in TEST_F(HeapTableTests, MVCCUpdateTransactionId)) to explicitly
check the return of table_->get_meta(rid, meta) with
ASSERT_TRUE(table_->get_meta(rid, meta)) (or EXPECT_FALSE where appropriate)
before accessing meta.xmin/meta.xmax so a failing get_meta() causes the test to
fail immediately; locate usages of table_->get_meta and add the assertion
immediately after each call that is followed by direct reads of meta.